package com.nulldev.util.io.legacy.cstreams;

import java.io.IOException;
import java.io.OutputStream;

import com.nulldev.util.concurrency.threadIt.v4.emapi.ExecutorManager;

public class CoderOutputStream extends OutputStream {
	private final CoderThread ct;

	private volatile OutputStream out;

	protected CoderOutputStream(final OutputStream out, final Coder coder) throws IOException {
		this.ct = new CoderThread(coder, out);
		this.out = ct.getOutputStreamSink();
		ExecutorManager.get().queueTask(this.ct);
	}

	public void write(int b) throws IOException {
		out.write(b);
	}

	public void write(byte b[]) throws IOException {
		write(b, 0, b.length);
	}

	public void write(byte b[], int off, int len) throws IOException {
		if ((off | len | (b.length - (len + off)) | (off + len)) < 0) {
			throw new IndexOutOfBoundsException();
		}
		out.write(b, off, len);
	}

	public void flush() throws IOException {
		out.flush();
	}

	public void close() throws IOException {
		try {
			flush();
		} catch (IOException ignored) {
			// why do we swallow exception here?!
		}
		out.close();
		try {
			ct.join();
		} catch (InterruptedException e) {
			throw new IOException(e);
		}
		ct.checkForException();
	}
}
